// 日期时间工具函数

/**
 * 格式化日期时间
 * @param {Date|string|number} date - 日期对象、时间戳或日期字符串
 * @param {string} format - 格式化模板，如 'YYYY-MM-DD HH:mm:ss'
 * @returns {string} 格式化后的日期时间字符串
 */
export const formatDate = (date, format = 'YYYY-MM-DD HH:mm:ss') => {
  // 将输入转换为Date对象
  const d = date instanceof Date ? date : new Date(date);
  
  // 检查日期是否有效
  if (isNaN(d.getTime())) {
    console.error('Invalid date:', date);
    return '';
  }

  const year = d.getFullYear();
  const month = String(d.getMonth() + 1).padStart(2, '0');
  const day = String(d.getDate()).padStart(2, '0');
  const hours = String(d.getHours()).padStart(2, '0');
  const minutes = String(d.getMinutes()).padStart(2, '0');
  const seconds = String(d.getSeconds()).padStart(2, '0');
  const milliseconds = String(d.getMilliseconds()).padStart(3, '0');

  // 替换模板中的占位符
  let result = format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hours)
    .replace('mm', minutes)
    .replace('ss', seconds)
    .replace('SSS', milliseconds);

  // 支持简写形式
  result = result
    .replace('YY', String(year).slice(2))
    .replace('M', String(d.getMonth() + 1))
    .replace('D', String(d.getDate()))
    .replace('H', String(d.getHours()))
    .replace('m', String(d.getMinutes()))
    .replace('s', String(d.getSeconds()));

  return result;
};

/**
 * 格式化日期（仅日期部分）
 * @param {Date|string|number} date - 日期对象、时间戳或日期字符串
 * @param {string} format - 格式化模板，默认 'YYYY-MM-DD'
 * @returns {string} 格式化后的日期字符串
 */
export const formatDateOnly = (date, format = 'YYYY-MM-DD') => {
  return formatDate(date, format);
};

/**
 * 格式化时间（仅时间部分）
 * @param {Date|string|number} date - 日期对象、时间戳或日期字符串
 * @param {string} format - 格式化模板，默认 'HH:mm:ss'
 * @returns {string} 格式化后的时间字符串
 */
export const formatTimeOnly = (date, format = 'HH:mm:ss') => {
  return formatDate(date, format);
};

/**
 * 获取当前日期时间
 * @param {string} format - 格式化模板
 * @returns {string} 当前日期时间的格式化字符串
 */
export const getCurrentDateTime = (format = 'YYYY-MM-DD HH:mm:ss') => {
  return formatDate(new Date(), format);
};

/**
 * 获取当前日期
 * @param {string} format - 格式化模板
 * @returns {string} 当前日期的格式化字符串
 */
export const getCurrentDate = (format = 'YYYY-MM-DD') => {
  return formatDateOnly(new Date(), format);
};

/**
 * 获取当前时间
 * @param {string} format - 格式化模板
 * @returns {string} 当前时间的格式化字符串
 */
export const getCurrentTime = (format = 'HH:mm:ss') => {
  return formatTimeOnly(new Date(), format);
};

/**
 * 计算两个日期之间的差值
 * @param {Date|string|number} date1 - 第一个日期
 * @param {Date|string|number} date2 - 第二个日期
 * @param {string} unit - 单位：'days', 'hours', 'minutes', 'seconds', 'milliseconds'
 * @returns {number} 差值
 */
export const diffDates = (date1, date2, unit = 'days') => {
  const d1 = date1 instanceof Date ? date1 : new Date(date1);
  const d2 = date2 instanceof Date ? date2 : new Date(date2);
  
  if (isNaN(d1.getTime()) || isNaN(d2.getTime())) {
    console.error('Invalid dates:', date1, date2);
    return NaN;
  }

  const diff = Math.abs(d2.getTime() - d1.getTime());
  
  switch (unit) {
    case 'days':
      return diff / (1000 * 60 * 60 * 24);
    case 'hours':
      return diff / (1000 * 60 * 60);
    case 'minutes':
      return diff / (1000 * 60);
    case 'seconds':
      return diff / 1000;
    case 'milliseconds':
    default:
      return diff;
  }
};

/**
 * 检查是否为今天
 * @param {Date|string|number} date - 要检查的日期
 * @returns {boolean} 是否为今天
 */
export const isToday = (date) => {
  const d = date instanceof Date ? date : new Date(date);
  const today = new Date();
  return d.getDate() === today.getDate() &&
         d.getMonth() === today.getMonth() &&
         d.getFullYear() === today.getFullYear();
};

/**
 * 检查是否为昨天
 * @param {Date|string|number} date - 要检查的日期
 * @returns {boolean} 是否为昨天
 */
export const isYesterday = (date) => {
  const d = date instanceof Date ? date : new Date(date);
  const yesterday = new Date();
  yesterday.setDate(yesterday.getDate() - 1);
  return d.getDate() === yesterday.getDate() &&
         d.getMonth() === yesterday.getMonth() &&
         d.getFullYear() === yesterday.getFullYear();
};

/**
 * 检查是否为明天
 * @param {Date|string|number} date - 要检查的日期
 * @returns {boolean} 是否为明天
 */
export const isTomorrow = (date) => {
  const d = date instanceof Date ? date : new Date(date);
  const tomorrow = new Date();
  tomorrow.setDate(tomorrow.getDate() + 1);
  return d.getDate() === tomorrow.getDate() &&
         d.getMonth() === tomorrow.getMonth() &&
         d.getFullYear() === tomorrow.getFullYear();
};

/**
 * 在日期上增加或减少时间
 * @param {Date|string|number} date - 基础日期
 * @param {number} value - 增加或减少的值
 * @param {string} unit - 单位：'days', 'hours', 'minutes', 'seconds', 'milliseconds', 'months', 'years'
 * @returns {Date} 计算后的日期对象
 */
export const addToDate = (date, value, unit = 'days') => {
  const d = date instanceof Date ? new Date(date) : new Date(date);
  
  if (isNaN(d.getTime())) {
    console.error('Invalid date:', date);
    return new Date();
  }

  switch (unit) {
    case 'days':
      d.setDate(d.getDate() + value);
      break;
    case 'hours':
      d.setHours(d.getHours() + value);
      break;
    case 'minutes':
      d.setMinutes(d.getMinutes() + value);
      break;
    case 'seconds':
      d.setSeconds(d.getSeconds() + value);
      break;
    case 'milliseconds':
      d.setMilliseconds(d.getMilliseconds() + value);
      break;
    case 'months':
      d.setMonth(d.getMonth() + value);
      break;
    case 'years':
      d.setFullYear(d.getFullYear() + value);
      break;
    default:
      console.warn('Unknown unit:', unit);
  }

  return d;
};

/**
 * 格式化相对时间（如：刚刚、几分钟前、几小时前、几天前等）
 * @param {Date|string|number} date - 日期对象、时间戳或日期字符串
 * @returns {string} 相对时间描述
 */
export const formatRelativeTime = (date) => {
  const d = date instanceof Date ? date : new Date(date);
  const now = new Date();
  const diffMs = now - d;
  
  if (isNaN(diffMs)) {
    return '';
  }

  const diffSecs = Math.floor(diffMs / 1000);
  const diffMins = Math.floor(diffSecs / 60);
  const diffHours = Math.floor(diffMins / 60);
  const diffDays = Math.floor(diffHours / 24);

  if (diffSecs < 60) {
    return '刚刚';
  } else if (diffMins < 60) {
    return `${diffMins}分钟前`;
  } else if (diffHours < 24) {
    return `${diffHours}小时前`;
  } else if (diffDays < 30) {
    return `${diffDays}天前`;
  } else {
    // 超过30天显示具体日期
    return formatDateOnly(d);
  }
};

/**
 * 获取某月的第一天
 * @param {Date|string|number} date - 日期对象、时间戳或日期字符串
 * @returns {Date} 该月的第一天
 */
export const getFirstDayOfMonth = (date) => {
  const d = date instanceof Date ? new Date(date) : new Date(date);
  d.setDate(1);
  d.setHours(0, 0, 0, 0);
  return d;
};

/**
 * 获取某月的最后一天
 * @param {Date|string|number} date - 日期对象、时间戳或日期字符串
 * @returns {Date} 该月的最后一天
 */
export const getLastDayOfMonth = (date) => {
  const d = date instanceof Date ? new Date(date) : new Date(date);
  d.setMonth(d.getMonth() + 1);
  d.setDate(0);
  d.setHours(23, 59, 59, 999);
  return d;
};

/**
 * 解析日期字符串为Date对象
 * @param {string} dateString - 日期字符串
 * @returns {Date|null} 解析后的Date对象，如果解析失败则返回null
 */
export const parseDate = (dateString) => {
  const date = new Date(dateString);
  return isNaN(date.getTime()) ? null : date;
};

/**
 * 检查日期是否有效
 * @param {Date|string|number} date - 要检查的日期
 * @returns {boolean} 是否为有效日期
 */
export const isValidDate = (date) => {
  const d = date instanceof Date ? date : new Date(date);
  return !isNaN(d.getTime());
};